#ifndef __cplusplus
#include "stdlib.h"
#endif
#include "string.h"

#include "tolua++.h"

/* Exported function */
TOLUA_API int  tolua_luaQFont_open (lua_State* tolua_S);

#include "./../luaQt.h"
#include "./../luaQFont.h"

/* function to release collected object via destructor */
#ifdef __cplusplus

static int tolua_collect_uint (lua_State* tolua_S)
{
 uint* self = (uint*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_qreal (lua_State* tolua_S)
{
 qreal* self = (qreal*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_QString (lua_State* tolua_S)
{
 QString* self = (QString*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_QVariant (lua_State* tolua_S)
{
 QVariant* self = (QVariant*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_QFont (lua_State* tolua_S)
{
 QFont* self = (QFont*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_QStringList (lua_State* tolua_S)
{
 QStringList* self = (QStringList*) tolua_tousertype(tolua_S,1,0);
	Mtolua_delete(self);
	return 0;
}
#endif


/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
 tolua_usertype(tolua_S,"uint");
 tolua_usertype(tolua_S,"qreal");
 tolua_usertype(tolua_S,"QString");
 tolua_usertype(tolua_S,"QStringList");
 tolua_usertype(tolua_S,"QFont");
 tolua_usertype(tolua_S,"QVariant");
 tolua_usertype(tolua_S,"QPaintDevice");
}

/* method: new of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_new00
static int tolua_luaQFont_QFont_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   QFont* tolua_ret = (QFont*)  Mtolua_new((QFont)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QFont");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_new00_local
static int tolua_luaQFont_QFont_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   QFont* tolua_ret = (QFont*)  Mtolua_new((QFont)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QFont");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_new01
static int tolua_luaQFont_QFont_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QFont",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* family = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  int pointSize = ((int)  tolua_tonumber(tolua_S,3,-1));
  int weight = ((int)  tolua_tonumber(tolua_S,4,-1));
  bool italic = ((bool)  tolua_toboolean(tolua_S,5,false));
  {
   QFont* tolua_ret = (QFont*)  Mtolua_new((QFont)(*family,pointSize,weight,italic));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QFont");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQFont_QFont_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_new01_local
static int tolua_luaQFont_QFont_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QFont",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QString* family = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  int pointSize = ((int)  tolua_tonumber(tolua_S,3,-1));
  int weight = ((int)  tolua_tonumber(tolua_S,4,-1));
  bool italic = ((bool)  tolua_toboolean(tolua_S,5,false));
  {
   QFont* tolua_ret = (QFont*)  Mtolua_new((QFont)(*family,pointSize,weight,italic));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QFont");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQFont_QFont_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_new02
static int tolua_luaQFont_QFont_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QFont",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QFont",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"QPaintDevice",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QFont* tolua_var_1 = ((const QFont*)  tolua_tousertype(tolua_S,2,0));
  QPaintDevice* pd = ((QPaintDevice*)  tolua_tousertype(tolua_S,3,0));
  {
   QFont* tolua_ret = (QFont*)  Mtolua_new((QFont)(*tolua_var_1,pd));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QFont");
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQFont_QFont_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_new02_local
static int tolua_luaQFont_QFont_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QFont",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QFont",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"QPaintDevice",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QFont* tolua_var_1 = ((const QFont*)  tolua_tousertype(tolua_S,2,0));
  QPaintDevice* pd = ((QPaintDevice*)  tolua_tousertype(tolua_S,3,0));
  {
   QFont* tolua_ret = (QFont*)  Mtolua_new((QFont)(*tolua_var_1,pd));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"QFont");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQFont_QFont_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_delete00
static int tolua_luaQFont_QFont_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: family of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_family00
static int tolua_luaQFont_QFont_family00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'family'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->family();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'family'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFamily of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setFamily00
static int tolua_luaQFont_QFont_setFamily00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  const QString* tolua_var_2 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFamily'", NULL);
#endif
  {
   self->setFamily(*tolua_var_2);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setFamily'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: styleName of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_styleName00
static int tolua_luaQFont_QFont_styleName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'styleName'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->styleName();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'styleName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setStyleName of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setStyleName00
static int tolua_luaQFont_QFont_setStyleName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  const QString* tolua_var_3 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setStyleName'", NULL);
#endif
  {
   self->setStyleName(*tolua_var_3);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setStyleName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: pointSize of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_pointSize00
static int tolua_luaQFont_QFont_pointSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pointSize'", NULL);
#endif
  {
   int tolua_ret = (int)  self->pointSize();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'pointSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setPointSize of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setPointSize00
static int tolua_luaQFont_QFont_setPointSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  int tolua_var_4 = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPointSize'", NULL);
#endif
  {
   self->setPointSize(tolua_var_4);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setPointSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: pointSizeF of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_pointSizeF00
static int tolua_luaQFont_QFont_pointSizeF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pointSizeF'", NULL);
#endif
  {
   qreal tolua_ret = (qreal)  self->pointSizeF();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((qreal)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"qreal");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(qreal));
     tolua_pushusertype(tolua_S,tolua_obj,"qreal");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'pointSizeF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setPointSizeF of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setPointSizeF00
static int tolua_luaQFont_QFont_setPointSizeF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"qreal",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  qreal tolua_var_5 = *((qreal*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPointSizeF'", NULL);
#endif
  {
   self->setPointSizeF(tolua_var_5);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setPointSizeF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: pixelSize of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_pixelSize00
static int tolua_luaQFont_QFont_pixelSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'pixelSize'", NULL);
#endif
  {
   int tolua_ret = (int)  self->pixelSize();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'pixelSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setPixelSize of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setPixelSize00
static int tolua_luaQFont_QFont_setPixelSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  int tolua_var_6 = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setPixelSize'", NULL);
#endif
  {
   self->setPixelSize(tolua_var_6);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setPixelSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: weight of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_weight00
static int tolua_luaQFont_QFont_weight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'weight'", NULL);
#endif
  {
   int tolua_ret = (int)  self->weight();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'weight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setWeight of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setWeight00
static int tolua_luaQFont_QFont_setWeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  int tolua_var_7 = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setWeight'", NULL);
#endif
  {
   self->setWeight(tolua_var_7);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setWeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: bold of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_bold00
static int tolua_luaQFont_QFont_bold00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'bold'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->bold();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'bold'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setBold of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setBold00
static int tolua_luaQFont_QFont_setBold00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  bool tolua_var_8 = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setBold'", NULL);
#endif
  {
   self->setBold(tolua_var_8);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setBold'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setStyle of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setStyle00
static int tolua_luaQFont_QFont_setStyle00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  QFont::Style style = ((QFont::Style) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setStyle'", NULL);
#endif
  {
   self->setStyle(style);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setStyle'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: style of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_style00
static int tolua_luaQFont_QFont_style00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'style'", NULL);
#endif
  {
   QFont::Style tolua_ret = (QFont::Style)  self->style();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'style'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: italic of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_italic00
static int tolua_luaQFont_QFont_italic00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'italic'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->italic();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'italic'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setItalic of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setItalic00
static int tolua_luaQFont_QFont_setItalic00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  bool b = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setItalic'", NULL);
#endif
  {
   self->setItalic(b);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setItalic'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: underline of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_underline00
static int tolua_luaQFont_QFont_underline00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'underline'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->underline();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'underline'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setUnderline of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setUnderline00
static int tolua_luaQFont_QFont_setUnderline00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  bool tolua_var_9 = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setUnderline'", NULL);
#endif
  {
   self->setUnderline(tolua_var_9);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setUnderline'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: overline of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_overline00
static int tolua_luaQFont_QFont_overline00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'overline'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->overline();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'overline'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setOverline of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setOverline00
static int tolua_luaQFont_QFont_setOverline00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  bool tolua_var_10 = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setOverline'", NULL);
#endif
  {
   self->setOverline(tolua_var_10);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setOverline'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: strikeOut of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_strikeOut00
static int tolua_luaQFont_QFont_strikeOut00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'strikeOut'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->strikeOut();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'strikeOut'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setStrikeOut of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setStrikeOut00
static int tolua_luaQFont_QFont_setStrikeOut00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  bool tolua_var_11 = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setStrikeOut'", NULL);
#endif
  {
   self->setStrikeOut(tolua_var_11);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setStrikeOut'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fixedPitch of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_fixedPitch00
static int tolua_luaQFont_QFont_fixedPitch00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'fixedPitch'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->fixedPitch();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fixedPitch'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setFixedPitch of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setFixedPitch00
static int tolua_luaQFont_QFont_setFixedPitch00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  bool tolua_var_12 = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setFixedPitch'", NULL);
#endif
  {
   self->setFixedPitch(tolua_var_12);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setFixedPitch'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: kerning of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_kerning00
static int tolua_luaQFont_QFont_kerning00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'kerning'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->kerning();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'kerning'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setKerning of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setKerning00
static int tolua_luaQFont_QFont_setKerning00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  bool tolua_var_13 = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setKerning'", NULL);
#endif
  {
   self->setKerning(tolua_var_13);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setKerning'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: styleHint of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_styleHint00
static int tolua_luaQFont_QFont_styleHint00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'styleHint'", NULL);
#endif
  {
   QFont::StyleHint tolua_ret = (QFont::StyleHint)  self->styleHint();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'styleHint'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: styleStrategy of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_styleStrategy00
static int tolua_luaQFont_QFont_styleStrategy00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'styleStrategy'", NULL);
#endif
  {
   QFont::StyleStrategy tolua_ret = (QFont::StyleStrategy)  self->styleStrategy();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'styleStrategy'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setStyleHint of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setStyleHint00
static int tolua_luaQFont_QFont_setStyleHint00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  QFont::StyleHint tolua_var_14 = ((QFont::StyleHint) (int)  tolua_tonumber(tolua_S,2,0));
  QFont::StyleStrategy tolua_var_15 = ((QFont::StyleStrategy) (int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setStyleHint'", NULL);
#endif
  {
   self->setStyleHint(tolua_var_14,tolua_var_15);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setStyleHint'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setStyleHint of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setStyleHint01
static int tolua_luaQFont_QFont_setStyleHint01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  QFont::StyleHint tolua_var_16 = ((QFont::StyleHint) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setStyleHint'", NULL);
#endif
  {
   self->setStyleHint(tolua_var_16);
  }
 }
 return 0;
tolua_lerror:
 return tolua_luaQFont_QFont_setStyleHint00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: setStyleStrategy of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setStyleStrategy00
static int tolua_luaQFont_QFont_setStyleStrategy00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  QFont::StyleStrategy s = ((QFont::StyleStrategy) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setStyleStrategy'", NULL);
#endif
  {
   self->setStyleStrategy(s);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setStyleStrategy'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: stretch of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_stretch00
static int tolua_luaQFont_QFont_stretch00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'stretch'", NULL);
#endif
  {
   int tolua_ret = (int)  self->stretch();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'stretch'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setStretch of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setStretch00
static int tolua_luaQFont_QFont_setStretch00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  int tolua_var_17 = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setStretch'", NULL);
#endif
  {
   self->setStretch(tolua_var_17);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setStretch'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: letterSpacing of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_letterSpacing00
static int tolua_luaQFont_QFont_letterSpacing00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'letterSpacing'", NULL);
#endif
  {
   qreal tolua_ret = (qreal)  self->letterSpacing();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((qreal)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"qreal");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(qreal));
     tolua_pushusertype(tolua_S,tolua_obj,"qreal");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'letterSpacing'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: letterSpacingType of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_letterSpacingType00
static int tolua_luaQFont_QFont_letterSpacingType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'letterSpacingType'", NULL);
#endif
  {
   QFont::SpacingType tolua_ret = (QFont::SpacingType)  self->letterSpacingType();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'letterSpacingType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setLetterSpacing of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setLetterSpacing00
static int tolua_luaQFont_QFont_setLetterSpacing00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"qreal",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  QFont::SpacingType type = ((QFont::SpacingType) (int)  tolua_tonumber(tolua_S,2,0));
  qreal spacing = *((qreal*)  tolua_tousertype(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setLetterSpacing'", NULL);
#endif
  {
   self->setLetterSpacing(type,spacing);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setLetterSpacing'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: wordSpacing of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_wordSpacing00
static int tolua_luaQFont_QFont_wordSpacing00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'wordSpacing'", NULL);
#endif
  {
   qreal tolua_ret = (qreal)  self->wordSpacing();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((qreal)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"qreal");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(qreal));
     tolua_pushusertype(tolua_S,tolua_obj,"qreal");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'wordSpacing'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setWordSpacing of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setWordSpacing00
static int tolua_luaQFont_QFont_setWordSpacing00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"qreal",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  qreal spacing = *((qreal*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setWordSpacing'", NULL);
#endif
  {
   self->setWordSpacing(spacing);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setWordSpacing'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: setCapitalization of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_setCapitalization00
static int tolua_luaQFont_QFont_setCapitalization00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  QFont::Capitalization tolua_var_18 = ((QFont::Capitalization) (int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'setCapitalization'", NULL);
#endif
  {
   self->setCapitalization(tolua_var_18);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'setCapitalization'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: capitalization of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_capitalization00
static int tolua_luaQFont_QFont_capitalization00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'capitalization'", NULL);
#endif
  {
   QFont::Capitalization tolua_ret = (QFont::Capitalization)  self->capitalization();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'capitalization'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: exactMatch of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_exactMatch00
static int tolua_luaQFont_QFont_exactMatch00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'exactMatch'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->exactMatch();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'exactMatch'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operatorQVariant of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont__QVariant00
static int tolua_luaQFont_QFont__QVariant00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operatorQVariant'", NULL);
#endif
  {
   QVariant tolua_ret = (QVariant)  self->operator  QVariant();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QVariant)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QVariant");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QVariant));
     tolua_pushusertype(tolua_S,tolua_obj,"QVariant");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.QVariant'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: isCopyOf of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_isCopyOf00
static int tolua_luaQFont_QFont_isCopyOf00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QFont",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
  const QFont* tolua_var_19 = ((const QFont*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'isCopyOf'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->isCopyOf(*tolua_var_19);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'isCopyOf'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: key of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_key00
static int tolua_luaQFont_QFont_key00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'key'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->key();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'key'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: toString of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_toString00
static int tolua_luaQFont_QFont_toString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'toString'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->toString();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'toString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: fromString of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_fromString00
static int tolua_luaQFont_QFont_fromString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  const QString* tolua_var_20 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'fromString'", NULL);
#endif
  {
   bool tolua_ret = (bool)  self->fromString(*tolua_var_20);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'fromString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: substitute of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_substitute00
static int tolua_luaQFont_QFont_substitute00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QFont",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* tolua_var_21 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  {
   QString tolua_ret = (QString)  QFont::substitute(*tolua_var_21);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'substitute'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: substitutes of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_substitutes00
static int tolua_luaQFont_QFont_substitutes00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QFont",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* tolua_var_22 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  {
   QStringList tolua_ret = (QStringList)  QFont::substitutes(*tolua_var_22);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QStringList)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QStringList");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QStringList));
     tolua_pushusertype(tolua_S,tolua_obj,"QStringList");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'substitutes'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: substitutions of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_substitutions00
static int tolua_luaQFont_QFont_substitutions00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   QStringList tolua_ret = (QStringList)  QFont::substitutions();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QStringList)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QStringList");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QStringList));
     tolua_pushusertype(tolua_S,tolua_obj,"QStringList");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'substitutions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: insertSubstitution of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_insertSubstitution00
static int tolua_luaQFont_QFont_insertSubstitution00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QFont",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* tolua_var_23 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  const QString* tolua_var_24 = ((const QString*)  tolua_tousertype(tolua_S,3,0));
  {
   QFont::insertSubstitution(*tolua_var_23,*tolua_var_24);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'insertSubstitution'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: insertSubstitutions of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_insertSubstitutions00
static int tolua_luaQFont_QFont_insertSubstitutions00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QFont",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const QStringList",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* tolua_var_25 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  const QStringList* tolua_var_26 = ((const QStringList*)  tolua_tousertype(tolua_S,3,0));
  {
   QFont::insertSubstitutions(*tolua_var_25,*tolua_var_26);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'insertSubstitutions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: removeSubstitutions of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_removeSubstitutions00
static int tolua_luaQFont_QFont_removeSubstitutions00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QFont",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QString",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QString* tolua_var_27 = ((const QString*)  tolua_tousertype(tolua_S,2,0));
  {
   QFont::removeSubstitutions(*tolua_var_27);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'removeSubstitutions'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: initialize of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_initialize00
static int tolua_luaQFont_QFont_initialize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   QFont::initialize();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'initialize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: cleanup of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_cleanup00
static int tolua_luaQFont_QFont_cleanup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   QFont::cleanup();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'cleanup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: cacheStatistics of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_cacheStatistics00
static int tolua_luaQFont_QFont_cacheStatistics00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   QFont::cacheStatistics();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'cacheStatistics'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: defaultFamily of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_defaultFamily00
static int tolua_luaQFont_QFont_defaultFamily00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'defaultFamily'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->defaultFamily();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'defaultFamily'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: lastResortFamily of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_lastResortFamily00
static int tolua_luaQFont_QFont_lastResortFamily00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lastResortFamily'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->lastResortFamily();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'lastResortFamily'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: lastResortFont of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_lastResortFont00
static int tolua_luaQFont_QFont_lastResortFont00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'lastResortFont'", NULL);
#endif
  {
   QString tolua_ret = (QString)  self->lastResortFont();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QString)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QString));
     tolua_pushusertype(tolua_S,tolua_obj,"QString");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'lastResortFont'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: resolve of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_resolve00
static int tolua_luaQFont_QFont_resolve00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const QFont",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
  const QFont* tolua_var_28 = ((const QFont*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'resolve'", NULL);
#endif
  {
   QFont tolua_ret = (QFont)  self->resolve(*tolua_var_28);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((QFont)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"QFont");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(QFont));
     tolua_pushusertype(tolua_S,tolua_obj,"QFont");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'resolve'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: resolve of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_resolve01
static int tolua_luaQFont_QFont_resolve01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const QFont",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const QFont* self = (const QFont*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'resolve'", NULL);
#endif
  {
   uint tolua_ret = (uint)  self->resolve();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((uint)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"uint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(uint));
     tolua_pushusertype(tolua_S,tolua_obj,"uint");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_luaQFont_QFont_resolve00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: resolve of class  QFont */
#ifndef TOLUA_DISABLE_tolua_luaQFont_QFont_resolve02
static int tolua_luaQFont_QFont_resolve02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"QFont",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"uint",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  QFont* self = (QFont*)  tolua_tousertype(tolua_S,1,0);
  uint mask = *((uint*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'resolve'", NULL);
#endif
  {
   self->resolve(mask);
  }
 }
 return 0;
tolua_lerror:
 return tolua_luaQFont_QFont_resolve01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* Open function */
TOLUA_API int tolua_luaQFont_open (lua_State* tolua_S)
{
 tolua_open(tolua_S);
 tolua_reg_types(tolua_S);
 tolua_module(tolua_S,NULL,0);
 tolua_beginmodule(tolua_S,NULL);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"QFont","QFont","",tolua_collect_QFont);
  #else
  tolua_cclass(tolua_S,"QFont","QFont","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"QFont");
   tolua_constant(tolua_S,"Helvetica",QFont::Helvetica);
   tolua_constant(tolua_S,"SansSerif",QFont::SansSerif);
   tolua_constant(tolua_S,"Times",QFont::Times);
   tolua_constant(tolua_S,"Serif",QFont::Serif);
   tolua_constant(tolua_S,"Courier",QFont::Courier);
   tolua_constant(tolua_S,"TypeWriter",QFont::TypeWriter);
   tolua_constant(tolua_S,"OldEnglish",QFont::OldEnglish);
   tolua_constant(tolua_S,"Decorative",QFont::Decorative);
   tolua_constant(tolua_S,"System",QFont::System);
   tolua_constant(tolua_S,"AnyStyle",QFont::AnyStyle);
   tolua_constant(tolua_S,"Cursive",QFont::Cursive);
   tolua_constant(tolua_S,"Monospace",QFont::Monospace);
   tolua_constant(tolua_S,"Fantasy",QFont::Fantasy);
   tolua_constant(tolua_S,"PreferDefault",QFont::PreferDefault);
   tolua_constant(tolua_S,"PreferBitmap",QFont::PreferBitmap);
   tolua_constant(tolua_S,"PreferDevice",QFont::PreferDevice);
   tolua_constant(tolua_S,"PreferOutline",QFont::PreferOutline);
   tolua_constant(tolua_S,"ForceOutline",QFont::ForceOutline);
   tolua_constant(tolua_S,"PreferMatch",QFont::PreferMatch);
   tolua_constant(tolua_S,"PreferQuality",QFont::PreferQuality);
   tolua_constant(tolua_S,"PreferAntialias",QFont::PreferAntialias);
   tolua_constant(tolua_S,"NoAntialias",QFont::NoAntialias);
   tolua_constant(tolua_S,"OpenGLCompatible",QFont::OpenGLCompatible);
   tolua_constant(tolua_S,"ForceIntegerMetrics",QFont::ForceIntegerMetrics);
   tolua_constant(tolua_S,"NoSubpixelAntialias",QFont::NoSubpixelAntialias);
   tolua_constant(tolua_S,"NoFontMerging",QFont::NoFontMerging);
   tolua_constant(tolua_S,"PreferDefaultHinting",QFont::PreferDefaultHinting);
   tolua_constant(tolua_S,"PreferNoHinting",QFont::PreferNoHinting);
   tolua_constant(tolua_S,"PreferVerticalHinting",QFont::PreferVerticalHinting);
   tolua_constant(tolua_S,"PreferFullHinting",QFont::PreferFullHinting);
   tolua_constant(tolua_S,"Thin",QFont::Thin);
   tolua_constant(tolua_S,"ExtraLight",QFont::ExtraLight);
   tolua_constant(tolua_S,"Light",QFont::Light);
   tolua_constant(tolua_S,"Normal",QFont::Normal);
   tolua_constant(tolua_S,"Medium",QFont::Medium);
   tolua_constant(tolua_S,"DemiBold",QFont::DemiBold);
   tolua_constant(tolua_S,"Bold",QFont::Bold);
   tolua_constant(tolua_S,"ExtraBold",QFont::ExtraBold);
   tolua_constant(tolua_S,"Black",QFont::Black);
   tolua_constant(tolua_S,"StyleNormal",QFont::StyleNormal);
   tolua_constant(tolua_S,"StyleItalic",QFont::StyleItalic);
   tolua_constant(tolua_S,"StyleOblique",QFont::StyleOblique);
   tolua_constant(tolua_S,"AnyStretch",QFont::AnyStretch);
   tolua_constant(tolua_S,"UltraCondensed",QFont::UltraCondensed);
   tolua_constant(tolua_S,"ExtraCondensed",QFont::ExtraCondensed);
   tolua_constant(tolua_S,"Condensed",QFont::Condensed);
   tolua_constant(tolua_S,"SemiCondensed",QFont::SemiCondensed);
   tolua_constant(tolua_S,"Unstretched",QFont::Unstretched);
   tolua_constant(tolua_S,"SemiExpanded",QFont::SemiExpanded);
   tolua_constant(tolua_S,"Expanded",QFont::Expanded);
   tolua_constant(tolua_S,"ExtraExpanded",QFont::ExtraExpanded);
   tolua_constant(tolua_S,"UltraExpanded",QFont::UltraExpanded);
   tolua_constant(tolua_S,"MixedCase",QFont::MixedCase);
   tolua_constant(tolua_S,"AllUppercase",QFont::AllUppercase);
   tolua_constant(tolua_S,"AllLowercase",QFont::AllLowercase);
   tolua_constant(tolua_S,"SmallCaps",QFont::SmallCaps);
   tolua_constant(tolua_S,"Capitalize",QFont::Capitalize);
   tolua_constant(tolua_S,"PercentageSpacing",QFont::PercentageSpacing);
   tolua_constant(tolua_S,"AbsoluteSpacing",QFont::AbsoluteSpacing);
   tolua_constant(tolua_S,"FamilyResolved",QFont::FamilyResolved);
   tolua_constant(tolua_S,"SizeResolved",QFont::SizeResolved);
   tolua_constant(tolua_S,"StyleHintResolved",QFont::StyleHintResolved);
   tolua_constant(tolua_S,"StyleStrategyResolved",QFont::StyleStrategyResolved);
   tolua_constant(tolua_S,"WeightResolved",QFont::WeightResolved);
   tolua_constant(tolua_S,"StyleResolved",QFont::StyleResolved);
   tolua_constant(tolua_S,"UnderlineResolved",QFont::UnderlineResolved);
   tolua_constant(tolua_S,"OverlineResolved",QFont::OverlineResolved);
   tolua_constant(tolua_S,"StrikeOutResolved",QFont::StrikeOutResolved);
   tolua_constant(tolua_S,"FixedPitchResolved",QFont::FixedPitchResolved);
   tolua_constant(tolua_S,"StretchResolved",QFont::StretchResolved);
   tolua_constant(tolua_S,"KerningResolved",QFont::KerningResolved);
   tolua_constant(tolua_S,"CapitalizationResolved",QFont::CapitalizationResolved);
   tolua_constant(tolua_S,"LetterSpacingResolved",QFont::LetterSpacingResolved);
   tolua_constant(tolua_S,"WordSpacingResolved",QFont::WordSpacingResolved);
   tolua_constant(tolua_S,"HintingPreferenceResolved",QFont::HintingPreferenceResolved);
   tolua_constant(tolua_S,"StyleNameResolved",QFont::StyleNameResolved);
   tolua_constant(tolua_S,"AllPropertiesResolved",QFont::AllPropertiesResolved);
   tolua_function(tolua_S,"new",tolua_luaQFont_QFont_new00);
   tolua_function(tolua_S,"new_local",tolua_luaQFont_QFont_new00_local);
   tolua_function(tolua_S,".call",tolua_luaQFont_QFont_new00_local);
   tolua_function(tolua_S,"new",tolua_luaQFont_QFont_new01);
   tolua_function(tolua_S,"new_local",tolua_luaQFont_QFont_new01_local);
   tolua_function(tolua_S,".call",tolua_luaQFont_QFont_new01_local);
   tolua_function(tolua_S,"new",tolua_luaQFont_QFont_new02);
   tolua_function(tolua_S,"new_local",tolua_luaQFont_QFont_new02_local);
   tolua_function(tolua_S,".call",tolua_luaQFont_QFont_new02_local);
   tolua_function(tolua_S,"delete",tolua_luaQFont_QFont_delete00);
   tolua_function(tolua_S,"family",tolua_luaQFont_QFont_family00);
   tolua_function(tolua_S,"setFamily",tolua_luaQFont_QFont_setFamily00);
   tolua_function(tolua_S,"styleName",tolua_luaQFont_QFont_styleName00);
   tolua_function(tolua_S,"setStyleName",tolua_luaQFont_QFont_setStyleName00);
   tolua_function(tolua_S,"pointSize",tolua_luaQFont_QFont_pointSize00);
   tolua_function(tolua_S,"setPointSize",tolua_luaQFont_QFont_setPointSize00);
   tolua_function(tolua_S,"pointSizeF",tolua_luaQFont_QFont_pointSizeF00);
   tolua_function(tolua_S,"setPointSizeF",tolua_luaQFont_QFont_setPointSizeF00);
   tolua_function(tolua_S,"pixelSize",tolua_luaQFont_QFont_pixelSize00);
   tolua_function(tolua_S,"setPixelSize",tolua_luaQFont_QFont_setPixelSize00);
   tolua_function(tolua_S,"weight",tolua_luaQFont_QFont_weight00);
   tolua_function(tolua_S,"setWeight",tolua_luaQFont_QFont_setWeight00);
   tolua_function(tolua_S,"bold",tolua_luaQFont_QFont_bold00);
   tolua_function(tolua_S,"setBold",tolua_luaQFont_QFont_setBold00);
   tolua_function(tolua_S,"setStyle",tolua_luaQFont_QFont_setStyle00);
   tolua_function(tolua_S,"style",tolua_luaQFont_QFont_style00);
   tolua_function(tolua_S,"italic",tolua_luaQFont_QFont_italic00);
   tolua_function(tolua_S,"setItalic",tolua_luaQFont_QFont_setItalic00);
   tolua_function(tolua_S,"underline",tolua_luaQFont_QFont_underline00);
   tolua_function(tolua_S,"setUnderline",tolua_luaQFont_QFont_setUnderline00);
   tolua_function(tolua_S,"overline",tolua_luaQFont_QFont_overline00);
   tolua_function(tolua_S,"setOverline",tolua_luaQFont_QFont_setOverline00);
   tolua_function(tolua_S,"strikeOut",tolua_luaQFont_QFont_strikeOut00);
   tolua_function(tolua_S,"setStrikeOut",tolua_luaQFont_QFont_setStrikeOut00);
   tolua_function(tolua_S,"fixedPitch",tolua_luaQFont_QFont_fixedPitch00);
   tolua_function(tolua_S,"setFixedPitch",tolua_luaQFont_QFont_setFixedPitch00);
   tolua_function(tolua_S,"kerning",tolua_luaQFont_QFont_kerning00);
   tolua_function(tolua_S,"setKerning",tolua_luaQFont_QFont_setKerning00);
   tolua_function(tolua_S,"styleHint",tolua_luaQFont_QFont_styleHint00);
   tolua_function(tolua_S,"styleStrategy",tolua_luaQFont_QFont_styleStrategy00);
   tolua_function(tolua_S,"setStyleHint",tolua_luaQFont_QFont_setStyleHint00);
   tolua_function(tolua_S,"setStyleHint",tolua_luaQFont_QFont_setStyleHint01);
   tolua_function(tolua_S,"setStyleStrategy",tolua_luaQFont_QFont_setStyleStrategy00);
   tolua_function(tolua_S,"stretch",tolua_luaQFont_QFont_stretch00);
   tolua_function(tolua_S,"setStretch",tolua_luaQFont_QFont_setStretch00);
   tolua_function(tolua_S,"letterSpacing",tolua_luaQFont_QFont_letterSpacing00);
   tolua_function(tolua_S,"letterSpacingType",tolua_luaQFont_QFont_letterSpacingType00);
   tolua_function(tolua_S,"setLetterSpacing",tolua_luaQFont_QFont_setLetterSpacing00);
   tolua_function(tolua_S,"wordSpacing",tolua_luaQFont_QFont_wordSpacing00);
   tolua_function(tolua_S,"setWordSpacing",tolua_luaQFont_QFont_setWordSpacing00);
   tolua_function(tolua_S,"setCapitalization",tolua_luaQFont_QFont_setCapitalization00);
   tolua_function(tolua_S,"capitalization",tolua_luaQFont_QFont_capitalization00);
   tolua_function(tolua_S,"exactMatch",tolua_luaQFont_QFont_exactMatch00);
   tolua_function(tolua_S,".QVariant",tolua_luaQFont_QFont__QVariant00);
   tolua_function(tolua_S,"isCopyOf",tolua_luaQFont_QFont_isCopyOf00);
   tolua_function(tolua_S,"key",tolua_luaQFont_QFont_key00);
   tolua_function(tolua_S,"toString",tolua_luaQFont_QFont_toString00);
   tolua_function(tolua_S,"fromString",tolua_luaQFont_QFont_fromString00);
   tolua_function(tolua_S,"substitute",tolua_luaQFont_QFont_substitute00);
   tolua_function(tolua_S,"substitutes",tolua_luaQFont_QFont_substitutes00);
   tolua_function(tolua_S,"substitutions",tolua_luaQFont_QFont_substitutions00);
   tolua_function(tolua_S,"insertSubstitution",tolua_luaQFont_QFont_insertSubstitution00);
   tolua_function(tolua_S,"insertSubstitutions",tolua_luaQFont_QFont_insertSubstitutions00);
   tolua_function(tolua_S,"removeSubstitutions",tolua_luaQFont_QFont_removeSubstitutions00);
   tolua_function(tolua_S,"initialize",tolua_luaQFont_QFont_initialize00);
   tolua_function(tolua_S,"cleanup",tolua_luaQFont_QFont_cleanup00);
   tolua_function(tolua_S,"cacheStatistics",tolua_luaQFont_QFont_cacheStatistics00);
   tolua_function(tolua_S,"defaultFamily",tolua_luaQFont_QFont_defaultFamily00);
   tolua_function(tolua_S,"lastResortFamily",tolua_luaQFont_QFont_lastResortFamily00);
   tolua_function(tolua_S,"lastResortFont",tolua_luaQFont_QFont_lastResortFont00);
   tolua_function(tolua_S,"resolve",tolua_luaQFont_QFont_resolve00);
   tolua_function(tolua_S,"resolve",tolua_luaQFont_QFont_resolve01);
   tolua_function(tolua_S,"resolve",tolua_luaQFont_QFont_resolve02);
  tolua_endmodule(tolua_S);
 tolua_endmodule(tolua_S);
 return 1;
}


#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 TOLUA_API int luaopen_luaQFont (lua_State* tolua_S) {
 return tolua_luaQFont_open(tolua_S);
};
#endif

